//! API兼容性测试
//! 
//! 测试不同产品类型的API兼容性和数据格式

use binance_sdk_unified::{
    client::BinanceClientBuilder, ProductType, Environment, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
    // 初始化日志
    tracing_subscriber::fmt::init();

    println!("🧪 API兼容性测试");
    println!("================================");

    // 测试所有产品类型
    let test_cases = vec![
        ("现货交易-生产网", ProductType::Spot, Environment::Live, "BTCUSDT"),
        ("现货交易-Demo模式", ProductType::Spot, Environment::Demo, "BTCUSDT"),
        ("USDT期货-生产网", ProductType::UsdM, Environment::Live, "BTCUSDT"),
        ("USDT期货-Demo模式", ProductType::UsdM, Environment::Demo, "BTCUSDT"),
        ("币本位期货-生产网", ProductType::CoinM, Environment::Live, "BTCUSD_PERP"),
        ("币本位期货-Demo模式", ProductType::CoinM, Environment::Demo, "BTCUSD_PERP"),
        ("期权交易-生产网", ProductType::Options, Environment::Live, "BTC-241227-100000-C"),
        ("期权交易-Demo模式", ProductType::Options, Environment::Demo, "BTC-241227-100000-C"),
    ];

    for (name, product_type, environment, symbol) in test_cases {
        println!("\n🔬 测试: {} ({:?})", name, product_type);
        println!("{}", "=".repeat(50));
        
        // 添加环境日志
        tracing::info!("[API_COMPAT] 测试: {} ({:?})", name, product_type);
        tracing::info!("[API_COMPAT] 产品类型: {:?}", product_type);
        tracing::info!("[API_COMPAT] 环境: {:?}", environment);

        // 从环境变量获取API密钥，如果没有则使用默认值
        let api_key = std::env::var("BINANCE_API_KEY").unwrap_or_else(|_| "test_api_key".to_string());
        let secret_key = std::env::var("BINANCE_SECRET_KEY").unwrap_or_else(|_| "test_secret_key".to_string());
        
        // 打印使用的API密钥信息
        println!("🔑 使用的API密钥信息:");
        println!("   API Key: {}", if api_key.len() > 8 { 
            format!("{}...{}", &api_key[..4], &api_key[api_key.len()-4..]) 
        } else { 
            api_key.clone() 
        });
        println!("   Secret Key: {}", if secret_key.len() > 8 { 
            format!("{}...{}", &secret_key[..4], &secret_key[secret_key.len()-4..]) 
        } else { 
            secret_key.clone() 
        });
        println!("   产品类型: {:?}", product_type);
        println!("   环境: {:?}", environment);

        // 创建客户端
        let client = BinanceClientBuilder::new(
            api_key,
            secret_key,
            product_type,
        )
        .environment(environment)
        .timeout(30)
        .retry_count(3)
        .build()?;

        // 测试API兼容性
        test_api_compatibility(&client, &name, symbol).await?;
    }

    println!("\n🎯 API兼容性测试完成！");
    println!("================================");

    Ok(())
}

/// 测试API兼容性
async fn test_api_compatibility(
    client: &binance_sdk_unified::BinanceClient, 
    name: &str, 
    symbol: &str
) -> Result<()> {
    println!("📡 测试API兼容性...");

    // 1. 服务器时间测试
    println!("   🕐 服务器时间测试...");
    match client.rest().market().get_server_time().await {
        Ok(server_time) => {
            println!("      ✅ 服务器时间: {}", server_time.server_time);
            println!("      ✅ 时间戳: {}", server_time.server_time);
        },
        Err(e) => {
            println!("      ❌ 服务器时间失败: {}", e);
            return Ok(());
        }
    }

    // 2. 交易对信息测试
    println!("   📊 交易对信息测试...");
    match client.rest().market().get_exchange_info().await {
        Ok(exchange_info) => {
            println!("      ✅ 交易对数量: {}", exchange_info.symbols.len());
            println!("      ✅ 服务器时间: {}", exchange_info.server_time);
            println!("      ✅ 时区: {}", exchange_info.timezone);
            
            // 显示前3个交易对
            for (i, symbol_info) in exchange_info.symbols.iter().take(3).enumerate() {
                println!("          {}. {} - 状态: {}", i+1, symbol_info.symbol, symbol_info.status);
            }
        },
        Err(e) => {
            println!("      ❌ 交易对信息失败: {}", e);
        }
    }

    // 3. 价格信息测试
    println!("   💰 价格信息测试...");
    match client.rest().market().get_price(Some(symbol)).await {
        Ok(price) => {
            println!("      ✅ {} 价格: {}", symbol, price.price);
        },
        Err(e) => {
            println!("      ❌ {} 价格失败: {}", symbol, e);
        }
    }

    // 4. 24小时统计测试
    println!("   📈 24小时统计测试...");
    match client.rest().market().get_24hr_ticker(Some(symbol)).await {
        Ok(ticker) => {
            println!("      ✅ {} 24小时统计:", symbol);
            println!("          价格: {}", ticker.last_price);
            println!("          变化: {} ({})", ticker.price_change, ticker.price_change_percent);
            println!("          成交量: {}", ticker.volume);
            println!("          成交额: {}", ticker.quote_volume);
        },
        Err(e) => {
            println!("      ❌ {} 24小时统计失败: {}", symbol, e);
        }
    }

    // 5. K线数据测试
    println!("   📊 K线数据测试...");
    match client.rest().market().get_klines(symbol, "1m", Some(5), None, None).await {
        Ok(klines) => {
            println!("      ✅ K线数据数量: {}", klines.len());
            if let Some(kline) = klines.first() {
                println!("          开盘价: {}", kline.open);
                println!("          最高价: {}", kline.high);
                println!("          最低价: {}", kline.low);
                println!("          收盘价: {}", kline.close);
                println!("          成交量: {}", kline.volume);
            }
        },
        Err(e) => {
            println!("      ❌ K线数据失败: {}", e);
        }
    }

    // 6. 账户信息测试（需要认证）
    println!("   🔐 账户信息测试...");
    match client.rest().account().get_account().await {
        Ok(account) => {
            println!("      ✅ 账户信息获取成功");
            
            // 根据产品类型显示不同的账户信息
            match client.config().product_type {
                ProductType::Spot => {
                    println!("          📊 现货账户:");
                    println!("              余额数量: {}", account.balances.len());
                    println!("              可交易: {}", account.can_trade);
                    println!("              可提现: {}", account.can_withdraw);
                    println!("              可充值: {}", account.can_deposit);
                },
                ProductType::UsdM | ProductType::CoinM => {
                    println!("          📊 期货账户:");
                    println!("              总钱包余额: {}", account.total_wallet_balance);
                    println!("              可用余额: {}", account.available_balance);
                    println!("              资产数量: {}", account.assets.len());
                    println!("              持仓数量: {}", account.positions.len());
                },
                ProductType::Options => {
                    println!("          📊 期权账户:");
                    println!("              账户类型: {}", account.account_type);
                    println!("              余额数量: {}", account.balances.len());
                },
                _ => {
                    println!("          📊 其他账户:");
                    println!("              账户类型: {}", account.account_type);
                    println!("              余额数量: {}", account.balances.len());
                }
            }
        },
        Err(e) => {
            println!("      ❌ 账户信息失败: {}", e);
            println!("          (这是正常的，因为使用了测试API密钥)");
        }
    }

    println!("   ✅ {} API兼容性测试完成", name);
    Ok(())
}
